home *** CD-ROM | disk | FTP | other *** search
/ Celestin Apprentice 2 / Apprentice-Release2.iso / Source Code / C / Applications / Macintosh Tracker 1.20 / source / Tracker Client Folder / Core 18⁄March⁄1994 / File.c < prev    next >
Encoding:
C/C++ Source or Header  |  1993-06-27  |  7.5 KB  |  385 lines  |  [TEXT/KAHL]
  1. /* File.c */
  2.  
  3. #include "File.h"
  4. #include <Script.h>
  5. #include "Memory.h"
  6. #include <Finder.h>
  7. #include "Compatibility.h"
  8. #include "Error.h"
  9. #include <Folders.h>
  10.  
  11.  
  12. static OSErr        LastError = 0;
  13.  
  14.  
  15. OSErr        FCreate(FSSpec* FileInfo, ulong Creator, ulong FileType)
  16.     {
  17.         LastError = FSpCreate(FileInfo,Creator,FileType,smSystemScript);
  18.         if (LastError != noErr)
  19.             {
  20.                 SetErrorStatus();
  21.             }
  22.         return LastError;
  23.     }
  24.  
  25.  
  26. OSErr        FOpenFile(FSSpec* FileInfo, short* FileReferenceOut)
  27.     {
  28.         short        RefNum;
  29.  
  30.         LastError = FSpOpenDF(FileInfo,fsRdWrPerm,FileReferenceOut);
  31.         if (LastError != noErr)
  32.             {
  33.                 SetErrorStatus();
  34.             }
  35.         return LastError;
  36.     }
  37.  
  38.  
  39. OSErr        FFlushFile(short FileReference)
  40.     {
  41.         short        vRefNum;
  42.  
  43.         LastError = GetVRefNum(FileReference,&vRefNum);
  44.         if (LastError == noErr)
  45.             {
  46.                 LastError = FlushVol(NIL,vRefNum);
  47.             }
  48.         if (LastError != noErr)
  49.             {
  50.                 SetErrorStatus();
  51.             }
  52.         return LastError;
  53.     }
  54.  
  55.  
  56. OSErr        FCloseFile(short FileReference)
  57.     {
  58.         short        vRefNum;
  59.  
  60.         LastError = GetVRefNum(FileReference,&vRefNum);
  61.         if (LastError == noErr)
  62.             {
  63.                 LastError = FSClose(FileReference);
  64.                 if (LastError == noErr)
  65.                     {
  66.                         LastError = FlushVol(NIL,vRefNum);
  67.                     }
  68.             }
  69.         if (LastError != noErr)
  70.             {
  71.                 SetErrorStatus();
  72.             }
  73.         return LastError;
  74.     }
  75.  
  76.  
  77. OSErr        FDeleteFile(FSSpec* FileInfo)
  78.     {
  79.         LastError = FSpDelete(FileInfo);
  80.         if (LastError != noErr)
  81.             {
  82.                 SetErrorStatus();
  83.             }
  84.         return LastError;
  85.     }
  86.  
  87.  
  88. OSErr        FDeleteIfExistsFile(FSSpec* FileInfo)
  89.     {
  90.         LastError = FSpDelete(FileInfo);
  91.         return LastError;
  92.     }
  93.  
  94.  
  95. OSErr        FWriteBlock(short FileReference, char* PointerToStart, ulong NumberOfBytes)
  96.     {
  97.         long        NumBytesDone;
  98.  
  99.         StackSizeTest();
  100.      LoopPoint:
  101.         NumBytesDone = NumberOfBytes;
  102.         LastError = FSWrite(FileReference,&NumBytesDone,PointerToStart);
  103.         if (LastError != noErr)
  104.             {
  105.                 SetErrorStatus();
  106.             }
  107.         PointerToStart += NumBytesDone;
  108.         NumberOfBytes -= NumBytesDone;
  109.         if ((LastError == noErr) && (NumberOfBytes != 0)) goto LoopPoint;
  110.         return LastError;
  111.     }
  112.  
  113.  
  114. OSErr        FReadBlock(short FileReference, char* PlaceToPut, ulong NumberOfBytes)
  115.     {
  116.         long        NumBytesDone;
  117.  
  118.         StackSizeTest();
  119.      LoopPoint:
  120.         NumBytesDone = NumberOfBytes;
  121.         LastError = FSRead(FileReference,&NumBytesDone,PlaceToPut);
  122.         if (LastError != noErr)
  123.             {
  124.                 SetErrorStatus();
  125.             }
  126.         PlaceToPut += NumBytesDone;
  127.         NumberOfBytes -= NumBytesDone;
  128.         if ((LastError == noErr) && (NumberOfBytes != 0)) goto LoopPoint;
  129.         return LastError;
  130.     }
  131.  
  132.  
  133. OSErr        FSetEOF(short FileReference, ulong NewEOF)
  134.     {
  135.         LastError = SetEOF(FileReference,NewEOF);
  136.         if (LastError != noErr)
  137.             {
  138.                 SetErrorStatus();
  139.             }
  140.         return LastError;
  141.     }
  142.  
  143.  
  144. OSErr        FGetEOF(short FileReference, long* EOFPos)
  145.     {
  146.         LastError = GetEOF(FileReference,EOFPos);
  147.         if (LastError != noErr)
  148.             {
  149.                 SetErrorStatus();
  150.             }
  151.         return LastError;
  152.     }
  153.  
  154.  
  155. OSErr        FSetFilePos(short FileReference, ulong NewFilePos)
  156.     {
  157.         long            EOF;
  158.  
  159.         LastError = GetEOF(FileReference,&EOF);
  160.         if (EOF < NewFilePos)
  161.             {
  162.                 LastError = SetEOF(FileReference,NewFilePos);
  163.             }
  164.         if (LastError == noErr)
  165.             {
  166.                 LastError = SetFPos(FileReference,fsFromStart,NewFilePos);
  167.             }
  168.         if (LastError != noErr)
  169.             {
  170.                 SetErrorStatus();
  171.             }
  172.         return LastError;
  173.     }
  174.  
  175.  
  176. OSErr        FGetFilePos(short FileReference, long* FilePos)
  177.     {
  178.         LastError = GetFPos(FileReference,FilePos);
  179.         if (LastError != noErr)
  180.             {
  181.                 SetErrorStatus();
  182.             }
  183.         return LastError;
  184.     }
  185.  
  186.  
  187. /* move data from one place on the disk to another. */
  188. /* data can overlap when it is to be moved backward, but not forward. */
  189. /* non-overlapping data has no problem */
  190. #define BigDiskBufferSize 65536
  191. #define SmallDiskBufferSize 8192
  192. #define EmergencyBufferSize 256
  193. OSErr        FMoveData(short SourceFile, ulong SourceIndex,
  194.                     short TargetFile, ulong TargetIndex, ulong NumBytes)
  195.     {
  196.         static char        EmergencyBuffer[EmergencyBufferSize];
  197.         Handle                DiskBuffer;
  198.         ulong                    DiskBufferSize;
  199.         char*                    BufPtr;
  200.  
  201.         DiskBuffer = AllocHandleCanFail(BigDiskBufferSize);
  202.         if (DiskBuffer == NIL)
  203.             {
  204.                 DiskBuffer = AllocHandleCanFail(SmallDiskBufferSize);
  205.             }
  206.         if (DiskBuffer != NIL)
  207.             {
  208.                 HLock(DiskBuffer);
  209.                 BufPtr = *DiskBuffer;
  210.                 DiskBufferSize = HandleSize(DiskBuffer);
  211.             }
  212.          else
  213.             {
  214.                 BufPtr = EmergencyBuffer;
  215.                 DiskBufferSize = EmergencyBufferSize;
  216.             }
  217.         while (NumBytes > 0)
  218.             {
  219.                 ulong        Count;
  220.  
  221.                 if (NumBytes > DiskBufferSize)
  222.                     {
  223.                         Count = DiskBufferSize;
  224.                     }
  225.                  else
  226.                     {
  227.                         Count = NumBytes;
  228.                     }
  229.                 FSetFilePos(SourceFile,SourceIndex);
  230.                 if (LastError != noErr)
  231.                     {
  232.                         goto ErrorPoint;
  233.                     }
  234.                 FReadBlock(SourceFile,BufPtr,Count);
  235.                 if (LastError != noErr)
  236.                     {
  237.                         goto ErrorPoint;
  238.                     }
  239.                 FSetFilePos(TargetFile,TargetIndex);
  240.                 if (LastError != noErr)
  241.                     {
  242.                         goto ErrorPoint;
  243.                     }
  244.                 FWriteBlock(TargetFile,BufPtr,Count);
  245.                 if (LastError != noErr)
  246.                     {
  247.                         goto ErrorPoint;
  248.                     }
  249.                 NumBytes -= Count;
  250.                 SourceIndex += Count;
  251.                 TargetIndex += Count;
  252.             }
  253.         if (DiskBuffer != NIL)
  254.             {
  255.                 ReleaseHandle(DiskBuffer);
  256.             }
  257.      ErrorPoint:
  258.         return LastError;
  259.     }
  260.  
  261.  
  262. OSErr        FLastError(void)
  263.     {
  264.         return LastError;
  265.     }
  266.  
  267.  
  268. void        FFindTempFolder(short* vRefNum, long* DirID)
  269.     {
  270.         FindFolder(kOnSystemDisk,kTemporaryFolderType,kCreateFolder,vRefNum,DirID);
  271.     }
  272.  
  273.  
  274. void        FFindPrefsFolder(short* vRefNum, long* DirID)
  275.     {
  276.         FindFolder(kOnSystemDisk,kPreferencesFolderType,kCreateFolder,vRefNum,DirID);
  277.     }
  278.  
  279.  
  280. void        FMakeFSSpec(short vRefNum, long DirID, PString FileName, FSSpec* FileInfo)
  281.     {
  282.         FSMakeFSSpec(vRefNum,DirID,FileName,FileInfo);
  283.     }
  284.  
  285.  
  286. /* find an unused temporary file name in the specified directory */
  287. void            FMakeTempFileName(short VRefNum, long DirID, PString Name)
  288.     {
  289.         long            Count;
  290.         short            Scan;
  291.         FSSpec        LocalFSSpec;
  292.         char            LocalName[] = "\pTempFile 01234567";
  293.         OSErr            Error;
  294.         FInfo            Junk;
  295.  
  296.         Count = TickCount();
  297.      LoopPoint:
  298.         for (Scan = 0; Scan < 8; Scan += 1)
  299.             {
  300.                 LocalName[LocalName[0]-Scan] = Byte2Hex(0x0f & (Count >> (Scan*4)));
  301.             }
  302.         FMakeFSSpec(VRefNum,DirID,(uchar*)LocalName,&LocalFSSpec);
  303.         Error = FSpGetFInfo(&LocalFSSpec,&Junk);
  304.         if (Error != fnfErr)
  305.             {
  306.                 Count += 1;
  307.                 goto LoopPoint;
  308.             }
  309.         MemCpy((char*)&(Name[0]),(char*)&(LocalFSSpec.name[0]),LocalFSSpec.name[0] + 1);
  310.         LastError = noErr;
  311.     }
  312.  
  313.  
  314. OSErr            FGetFInfo(FSSpec* FileInfo, FInfo* FinderInfo)
  315.     {
  316.         LastError = FSpGetFInfo(FileInfo,FinderInfo);
  317.         if (LastError != noErr)
  318.             {
  319.                 SetErrorStatus();
  320.             }
  321.         return LastError;
  322.     }
  323.  
  324.  
  325. OSErr            FGetContainingDirectory(short FileRefNum, short* HardVRefNum, long* DirID)
  326.     {
  327.         FCBPBRec        MyFCB;
  328.  
  329.         MyFCB.ioCompletion = NIL;
  330.         MyFCB.ioFCBIndx = 0;
  331.         MyFCB.ioVRefNum = 0;
  332.         MyFCB.ioRefNum = FileRefNum;
  333.         MyFCB.ioNamePtr = NIL;
  334.         LastError = PBGetFCBInfo(&MyFCB,False);
  335.         if (LastError == noErr)
  336.             {
  337.                 LastError = MyFCB.ioResult;
  338.             }
  339.         if (LastError != noErr)
  340.             {
  341.                 SetErrorStatus();
  342.             }
  343.          else
  344.             {
  345.                 *HardVRefNum = MyFCB.ioFCBVRefNum;
  346.                 *DirID = MyFCB.ioFCBParID;
  347.             }
  348.         return LastError;
  349.     }
  350.  
  351.  
  352. OSErr            FDerefFolder(FSSpec* TheFolder, long* FolderID)
  353.     {
  354.         CInfoPBRec        MyPB;
  355.  
  356.         MyPB.dirInfo.ioCompletion = NIL;
  357.         MyPB.dirInfo.ioVRefNum = TheFolder->vRefNum;
  358.         MyPB.dirInfo.ioNamePtr = TheFolder->name;
  359.         MyPB.dirInfo.ioFDirIndex = 0;
  360.         MyPB.dirInfo.ioDrDirID = TheFolder->parID;
  361.         LastError = PBGetCatInfo(&MyPB,False);
  362.         if (LastError == noErr)
  363.             {
  364.                 LastError = MyPB.dirInfo.ioResult;
  365.             }
  366.         if (LastError != noErr)
  367.             {
  368.                 SetErrorStatus();
  369.             }
  370.          else
  371.             {
  372.                 if ((MyPB.dirInfo.ioFlAttrib & 16) == 0)
  373.                     {
  374.                         /* if it's not a directory, then we return error */
  375.                         LastError = dirNFErr;
  376.                         SetErrorStatus();
  377.                     }
  378.                  else
  379.                     {
  380.                         *FolderID = MyPB.dirInfo.ioDrDirID;
  381.                     }
  382.             }
  383.         return LastError;
  384.     }
  385.